/**
 * 请求封装
 * 封装微信请求API，统一处理请求参数、错误处理和认证
 */

// API基础URL
const BASE_URL = 'http://127.0.0.1:5002/api';

/**
 * 获取保存的JWT令牌
 */
const getToken = () => {
  try {
    const token = wx.getStorageSync('token') || '';
    console.log('[Token] 获取本地存储Token:', token ? '成功' : '未找到');
    return token;
  } catch (e) {
    console.error('[Token] 获取本地存储Token失败:', e);
    return '';
  }
};

/**
 * 发送HTTP请求
 * @param {Object} options - 请求选项
 * @param {string} options.url - 请求URL（相对路径）
 * @param {string} options.method - 请求方法 (GET, POST, PUT, DELETE等)
 * @param {Object} options.data - 请求数据
 * @param {boolean} options.auth - 是否需要认证 (默认true)
 * @returns {Promise} 请求结果Promise
 */
const request = (options) => {
  const { url, method = 'GET', data = {}, auth = true } = options;
  
  // 构建完整URL
  const fullUrl = `${BASE_URL}${url}`;
  
  // 准备请求头
  const header = {
    'Content-Type': 'application/json'
  };
  
  // 如果需要认证，添加令牌
  if (auth) {
    const token = getToken();
    if (token) {
      header['x-auth-token'] = token;
      console.log(`[请求认证] 添加令牌到请求头`);
    } else {
      console.warn('[请求认证] 需要认证但未找到令牌');
    }
  }
  
  console.log(`[请求开始] ${method} ${fullUrl}`, data);
  
  // 检查数据中是否包含日期字段
  if (data && typeof data === 'object') {
    // 检查常见的日期字段
    const dateFields = ['measuredAt', 'timestamp', 'date', 'createdAt', 'updatedAt'];
    dateFields.forEach(field => {
      if (data[field]) {
        console.log(`[请求日期字段] ${field}:`, data[field]);
        try {
          const parsedDate = new Date(data[field]);
          console.log(`[请求日期字段] ${field} 解析后:`, parsedDate.toLocaleString());
        } catch (e) {
          console.error(`[请求日期字段] ${field} 解析失败:`, e);
        }
      }
    });
  }
  
  // 日期字段特殊处理 - 检测measuredAt字段
  if (data && data.measuredAt) {
    const beforeJson = data.measuredAt;
    // 将数据转为JSON再解析回来，模拟请求过程
    const jsonData = JSON.stringify(data);
    const parsedData = JSON.parse(jsonData);
    const afterJson = parsedData.measuredAt;
    
    console.log('[日期JSON转换测试] 转换前:', beforeJson);
    console.log('[日期JSON转换测试] JSON字符串:', jsonData);
    console.log('[日期JSON转换测试] 转换后:', afterJson);
    
    // 检查转换后的日期是否有效
    try {
      const beforeDate = new Date(beforeJson);
      const afterDate = new Date(afterJson);
      
      console.log('[日期JSON转换测试] 转换前日期对象:', beforeDate.toISOString());
      console.log('[日期JSON转换测试] 转换后日期对象:', afterDate.toISOString());
      
      if (beforeDate.getTime() !== afterDate.getTime()) {
        console.warn('[日期JSON转换测试] 警告：日期在JSON转换前后发生了变化!');
      }
    } catch (e) {
      console.error('[日期JSON转换测试] 日期解析失败:', e);
    }
  }
  
  // 返回Promise
  return new Promise((resolve, reject) => {
    wx.request({
      url: fullUrl,
      method,
      data,
      header,
      success: (res) => {
        console.log(`[请求成功] ${method} ${fullUrl}, 状态码: ${res.statusCode}`, res.data);
        
        // 检查响应中的日期字段
        if (res.data && typeof res.data === 'object') {
          // 检查常见的日期字段
          const dateFields = ['measuredAt', 'timestamp', 'date', 'createdAt', 'updatedAt'];
          const checkObject = (obj, path = '') => {
            if (!obj || typeof obj !== 'object') return;
            
            // 检查当前对象的字段
            Object.keys(obj).forEach(key => {
              const fieldPath = path ? `${path}.${key}` : key;
              if (dateFields.includes(key) && obj[key]) {
                console.log(`[响应日期字段] ${fieldPath}:`, obj[key]);
                try {
                  const parsedDate = new Date(obj[key]);
                  console.log(`[响应日期字段] ${fieldPath} 解析后:`, parsedDate.toLocaleString());
                } catch (e) {
                  console.error(`[响应日期字段] ${fieldPath} 解析失败:`, e);
                }
              }
              
              // 递归检查嵌套对象
              if (obj[key] && typeof obj[key] === 'object') {
                checkObject(obj[key], fieldPath);
              }
            });
          };
          
          checkObject(res.data);
        }
        
        // 检查HTTP状态码
        if (res.statusCode >= 200 && res.statusCode < 300) {
          resolve(res.data);
        } else if (res.statusCode === 401) {
          console.error('[认证错误] 身份验证失败，请重新登录');
          // 清除无效的令牌
          try {
            wx.removeStorageSync('token');
            console.log('[认证错误] 已清除无效令牌');
          } catch (e) {
            console.error('[认证错误] 清除令牌失败:', e);
          }
          
          // 跳转到登录页
          wx.navigateTo({
            url: '/pages/login/login'
          });
          reject(new Error('未授权，请重新登录'));
        } else {
          // 其他错误
          let errorMsg = res.data && res.data.message ? res.data.message : '请求失败';
          console.error(`[请求失败] ${method} ${fullUrl}, 状态码: ${res.statusCode}`, res.data);
          reject(new Error(errorMsg));
        }
      },
      fail: (err) => {
        // 网络错误等
        console.error(`[请求错误] ${method} ${fullUrl}, 错误详情:`, err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
};

/**
 * 微信登录
 * 获取微信用户授权，并将code和用户信息发送到后端进行登录
 * @returns {Promise} 登录结果
 */
const wxLogin = async (withUserInfo = true) => {
  console.log('[微信登录] 开始登录流程, 获取用户信息:', withUserInfo);
  
  try {
    // 获取微信登录code
    const loginPromise = new Promise((resolve, reject) => {
      wx.login({
        success: (res) => {
          console.log('[微信登录] 获取code成功:', res.code);
          resolve(res.code);
        },
        fail: (err) => {
          console.error('[微信登录] 获取code失败:', err);
          reject(new Error('获取微信登录凭证失败'));
        }
      });
    });
    
    const code = await loginPromise;
    let userInfo = null;
    
    // 是否需要获取用户信息
    if (withUserInfo && typeof withUserInfo !== 'boolean') {
      // 如果withUserInfo不是布尔值，那么它就是直接传入的用户信息对象
      userInfo = withUserInfo;
      console.log('[微信登录] 使用直接传入的用户信息:', userInfo);
    } else if (withUserInfo === true) {
      console.log('[微信登录] 准备获取用户资料');
      try {
        // 获取用户信息
        const userInfoRes = await new Promise((resolve, reject) => {
          wx.getUserProfile({
            desc: '用于完善您的个人资料',
            success: (res) => {
              console.log('[微信登录] 获取用户资料成功:', res.userInfo);
              resolve(res);
            },
            fail: (err) => {
              console.error('[微信登录] 获取用户资料失败:', err);
              reject(err);
            }
          });
        });
        userInfo = userInfoRes.userInfo;
      } catch (error) {
        console.warn('[微信登录] 用户拒绝授权获取信息，将只使用code登录');
        // 用户拒绝，继续使用code登录
      }
    } else {
      console.log('[微信登录] 不获取用户信息，只使用code登录');
    }
    
    // 构建登录请求数据
    const loginData = { code };
    
    // 如果有用户信息，添加到请求中
    if (userInfo) {
      // 将用户信息字段添加到登录数据中
      // 直接使用完整的userInfo对象，保持字段名称一致性
      loginData.userInfo = userInfo;
    }
    
    console.log('[微信登录] 发送登录请求数据:', loginData);
    
    // 发送登录请求
    const loginResult = await request({
      url: '/users/wx-login',
      method: 'POST',
      data: loginData,
      auth: false // 登录不需要认证
    });
    
    console.log('[微信登录] 登录成功, 服务器返回:', loginResult);
    
    // 增加详细调试信息
    console.log('[微信登录] 解析的用户数据:', loginResult.data);
    console.log('[微信登录] 用户ID:', loginResult.data._id);
    console.log('[微信登录] OpenID:', loginResult.data.openid);
    
    // 检查服务器响应格式
    if (!loginResult.success) {
      console.error('[微信登录] 服务器返回错误:', loginResult.message);
      return {
        success: false,
        error: loginResult.message || '登录失败'
      };
    }
    
    // 从响应中提取用户数据 - 服务器返回格式为 {success, message, data: {token, _id, ...}}
    const userData = loginResult.data;
    
    if (!userData) {
      console.error('[微信登录] 服务器响应中没有data字段');
      return {
        success: false,
        error: '服务器响应格式错误'
      };
    }
    
    console.log('[微信登录] 解析的用户数据:', userData);
    
    // 保存令牌到本地存储
    if (userData.token) {
      try {
        wx.setStorageSync('token', userData.token);
        console.log('[微信登录] 令牌已保存到本地存储');
      } catch (e) {
        console.error('[微信登录] 保存令牌失败:', e);
      }
    } else {
      console.error('[微信登录] 服务器返回的数据中没有token:', userData);
    }
    
    // 返回前端需要的数据格式
    return {
      success: true,
      token: userData.token,
      user: userData,
      isProfileComplete: userData.isProfileComplete || false
    };
  } catch (error) {
    console.error('[微信登录] 登录过程出错:', error);
    return {
      success: false,
      error: error.message || '登录失败，请稍后再试'
    };
  }
};

/**
 * 获取用户个人资料
 * @returns {Promise} 用户资料
 */
const getUserProfile = () => {
  console.log('[API] 获取用户资料');
  return request({
    url: '/users/profile',
    method: 'GET'
  });
};

/**
 * 更新用户健康档案
 * @param {Object} data - 健康档案数据
 * @returns {Promise} - 请求结果
 */
const updateHealthProfile = (data) => {
  // 确保重要字段能够正确更新
  const processedData = {
    ...data,
    // 显式提取这些字段，确保它们被包含在请求中
    weight: data.weight,
    bloodType: data.bloodType,
    physiologicalStatus: data.physiologicalStatus,
    activityLevel: data.activityLevel,
    hasHypertension: data.hasHypertension,
    hasHeartDisease: data.hasHeartDisease,
    hasKidneyDisease: data.hasKidneyDisease,
    familyDiabetes: data.familyDiabetes
  };
  
  // 添加调试信息，确认重要字段的值
  console.log('[API] 健康档案更新 - 重要字段值:', {
    weight: processedData.weight,
    bloodType: processedData.bloodType,
    physiologicalStatus: processedData.physiologicalStatus,
    activityLevel: processedData.activityLevel
  });

  console.log('[API] 更新健康档案 - 最终请求数据:', JSON.stringify(processedData, null, 2));
  
  return request({
    url: '/users/health-profile',
    method: 'PUT',
    data: processedData
  });
};

/**
 * 更新用户个人信息
 * @param {Object} data - 用户个人信息数据
 * @returns {Promise} - 请求结果
 */
const updateUserProfile = (data) => {
  // 确保重要字段能够正确更新
  const processedData = {
    ...data,
    // 显式提取这些字段，确保它们被包含在请求中
    weight: data.weight,
    bloodType: data.bloodType,
    physiologicalStatus: data.physiologicalStatus,
    activityLevel: data.activityLevel
  };
  
  // 添加调试信息，确认重要字段的值
  console.log('[API] 个人信息更新 - 重要字段值:', {
    weight: processedData.weight,
    bloodType: processedData.bloodType,
    physiologicalStatus: processedData.physiologicalStatus,
    activityLevel: processedData.activityLevel
  });

  console.log('[API] 更新个人信息 - 最终请求数据:', JSON.stringify(processedData, null, 2));
  
  return request({
    url: '/users/profile',
    method: 'PUT',
    data: processedData
  });
};

// 导出API
module.exports = {
  request,
  wxLogin,
  getUserProfile,
  updateHealthProfile,
  updateUserProfile
}; 